home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / langs / sozo2 / scsrc20.lzh / SZADB.LZH / PCS.C < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-24  |  7.8 KB  |  470 lines
  1. /* Copyright (c) 1990 by Sozobon, Limited.  Authors: Johann Ruegg, Don Dugger
  2.  *
  3.  * Permission is granted to anyone to use this software for any purpose
  4.  * on any computer system, and to redistribute it freely, with the
  5.  * following restrictions:
  6.  * 1) No charge may be made other than reasonable charges for reproduction.
  7.  * 2) Modified versions must be clearly marked as such.
  8.  * 3) The authors are not responsible for any harmful consequences
  9.  *    of using this software, even if they result from defects in it.
  10.  *
  11.  *    pcs.c
  12.  */
  13.  
  14. #include <setjmp.h>
  15. #include "adb.h"
  16.  
  17. #define IN_PCS
  18. #include "lang.h"
  19.  
  20. #ifndef NULL
  21. #define NULL    0L
  22. #endif
  23.  
  24. unsigned long esp;
  25. char cmdbuf[256];
  26. struct basepg *bpage;
  27. extern long dot;
  28. extern int dotset;
  29. extern int dotoff;
  30. extern struct regs regs[];
  31.  
  32. struct bpt bpt[MAXBPTS] = 0;
  33.  
  34. struct bpt *findbpt();
  35.  
  36. prstack(argsflg)
  37. {
  38.     int first;
  39.     long pc, fp, sp, ap;
  40.     long npc, nfp, brpc;
  41.     long getn(), atbranch();
  42.     struct basepg *bp = bpage;
  43.  
  44.     pc = *(regs[PC].value);
  45.     fp = *(regs[FP].value);
  46.     sp = *(regs[SP].value);
  47.     first = 1;
  48.  
  49.     while (pc >= (long)bp->p_tbase && 
  50.            pc < (long)bp->p_tbase + bp->p_tlen) {
  51.         prtf("%A", pc);
  52.         if (first && (atlink(pc) || atrts(pc) ||
  53.             ((brpc = atbranch(pc)) && atlink(brpc)))) {
  54.             npc = getn(sp, 4);
  55.             nfp = fp;
  56.             ap = sp+4;
  57.         } else {
  58.             nfp = getn(fp,4);
  59.             npc = getn(fp+4,4);
  60.             ap = fp+8;
  61.         }
  62.         if (argsflg)
  63.             funargs(npc, ap, nfp);
  64.         putchr('\n');
  65.  
  66.         if (nfp < (long)bp->p_bbase+bp->p_blen ||
  67.             nfp > (long)bp->p_hitpa ||
  68.             nfp <= sp || nfp < fp ||
  69.             (nfp == fp && !first))
  70.             break;
  71.         pc = npc;
  72.         fp = nfp;
  73.         first = 0;
  74.     }
  75. }
  76.  
  77. funargs(retpc, argp, limit)
  78. long retpc, argp, limit;
  79. {
  80.     int i, n;
  81.     unsigned w;
  82.  
  83.     n = numargs(retpc);
  84.  
  85.     if (n == 0) {        /* optimized out maybe */
  86. /*        prtf("(? at %I)", argp); */
  87.         prtf(M1, argp);
  88.         return;
  89.     }
  90.  
  91.     putchr('(');
  92.     for (i=0; i<n; i++, argp += 2) {
  93.         w = getn(argp, 2);
  94.         prt4x(w);
  95.         if (argp+2 >= limit)
  96.             break;
  97.         if ((i+1) < n)
  98.             putchr(',');
  99.     }
  100.     putchr(')');
  101. }
  102.  
  103. prt4x(w)
  104. unsigned w;
  105. {
  106.     int i, j, k;
  107.  
  108.     k = 12;
  109.     for (k=12; k >= 0; k -= 4) {
  110.         j = w >> k;
  111.         j &= 0xf;
  112.         putchr("0123456789abcdef"[j]);
  113.     }
  114. }
  115.  
  116. numargs(retpc)
  117. long retpc;
  118. {
  119.     int ins, n;
  120.     long getn();
  121.  
  122.     ins = getn(retpc, 2);
  123.     if ((ins & 0xf1ff) == 0x504f ||
  124.         (ins & 0xf1ff) == 0x508f) {    /* addq.[wl] #n,A7 */
  125.         n = (ins>>9) & 7;
  126.         if (n == 0)
  127.             n = 8;
  128.     } else if (ins == 0xdefc) {    /* adda.w #n,A7 */
  129.         n = getn(retpc+2, 2);
  130.     } else if (ins == 0xdffc) {    /* adda.l #n,A7 */
  131.         n = getn(retpc+2, 4);
  132.     } else
  133.         n = 0;
  134.  
  135.     if (n < 0)
  136.         n = 0;
  137.     return n/2;
  138. }
  139.  
  140. long
  141. atbranch(loc)
  142. long loc;
  143. {
  144.     int ins, i;
  145.  
  146.     ins = getn(loc, 2);
  147.     if ((ins & 0xff00) == 0x6000) {
  148.         i = ins & 0xff;
  149.         if (i == 0)
  150.             i = getn(loc+2, 2);
  151.         return loc+2+i;
  152.     }
  153.     return 0;
  154. }
  155.  
  156. atlink(loc)
  157. long loc;
  158. {
  159.     int ins;
  160.  
  161.     ins = getn(loc, 2);
  162.     return (ins == 0x4e56);    /* link a6,#N */
  163. }
  164.  
  165. atrts(loc)
  166. long loc;
  167. {
  168.     int ins;
  169.  
  170.     ins = getn(loc, 2);
  171.     return (ins == 0x4e75);
  172. }
  173.  
  174. prbasepg()
  175. {
  176.     int n, i;
  177.     unsigned char c;
  178.     struct basepg *bp;
  179.  
  180.     if (dotset)
  181.         bp = (struct basepg *)dot;
  182.     else
  183.         bp = bpage;
  184.  
  185. /*    prtf("base page at %I", bp); */
  186.     prtf(M2, bp);
  187. /*    prt("low tpa ");    */
  188.     prt(M3);
  189.     prtn(bp->p_lowtpa, 10);
  190. /*    prt("  hi tpa  ");    */
  191.     prt(M4);
  192.     prtn(bp->p_hitpa, 10);
  193. /*    prt("\ntext at ");    */
  194.     prt(M5);
  195.     prtn(bp->p_tbase, 10);
  196. /*    prt("  size    ");    */
  197.     prt(M6);
  198.     prtn(bp->p_tlen, 10);
  199. /*    prt("\ndata at ");    */
  200.     prt(M7);
  201.     prtn(bp->p_dbase, 10);
  202. /*    prt("  size    ");    */
  203.     prt(M6);
  204.     prtn(bp->p_dlen, 10);
  205. /*    prt("\nbss at  ");    */
  206.     prt(M8);
  207.     prtn(bp->p_bbase, 10);
  208. /*    prt("  size    ");    */
  209.     prt(M6);
  210.     prtn(bp->p_blen, 10);
  211. /*    prt("\nenv ptr ");    */
  212.     prt(M9);
  213.     prtn(bp->p_env, 10);
  214. /*    prt("  parent  ");    */
  215.     prt(M10);
  216.     prtn(bp->p_parent, 10);
  217.  
  218.     prtf("\nargs: ");
  219.     n = bp->p_cmdlin[0];
  220.     for (i=0; i<n; i++) {
  221.         c = bp->p_cmdlin[1+i];
  222.         if (c < ' ') {
  223.             putchr('^');
  224.             c += 'A';
  225.         }
  226.         putchr(c);
  227.     }
  228.     putchr('\n');
  229. }
  230.  
  231. loadpcs()
  232. {
  233.     int **ip;
  234.     char parms[80], *envp;
  235.     extern struct basepg *gemdos();
  236.     extern struct file binary;
  237.     extern struct basepg *_base;
  238.     extern unsigned long ossp;
  239.  
  240.     parms[0] = '\0';
  241.     envp = _base->p_env;
  242.     if ((bpage = gemdos(0x4b, 3, binary.name, parms, envp)) < 0) {
  243. /*        prtf("can't load %s\n", binary.name);    */
  244.         prtf(M11, binary.name);
  245.         return -1;
  246.     }
  247.     ip = (int **)(bpage->p_hitpa);
  248.     *--ip = (int *)bpage;
  249.     --ip;
  250.     *(regs[SP].value) = (unsigned long)ip;
  251.     *(regs[PC].value) = (unsigned long)bpage->p_tbase;
  252.     *(regs[XSP].value) = ossp;
  253. #ifdef OLD
  254.     bpage->p_parent = _base;
  255. #else
  256.     bpage->p_parent = 0;
  257. #endif
  258.     return 0;
  259. }
  260.  
  261. cmdcol(c, fmt, get)
  262. int c;
  263. char *fmt;
  264. long (*get)();
  265. {
  266.     extern struct bpt *freebpt();
  267.     struct bpt *bp;
  268.     extern int lasttrap;
  269.     extern char *tnm[];
  270.  
  271.     switch (c) {
  272.     case 's':        /* single step a sub-process */
  273.     case 'S':
  274.     case 'c':        /* continue a sub-program */
  275.     case 'C':
  276.         if (dotset)
  277.             *(regs[PC].value) = dot;
  278.         else
  279.             dot = *(regs[PC].value);
  280.         getargs();
  281.         if (c == 'c' || c == 'C') {
  282.             if (findbpt(dot)) {
  283.                 ptrace(SSTEP, 0, 0, 0);
  284.                 dot = *(regs[PC].value);
  285.             }
  286.             if (findbpt(dot) == NULL) {
  287.                 setbpt(bpt, MAXBPTS);
  288.                 winswtch();
  289.                 ptrace(CONTINUE, 0, 0, 0);
  290.                 winswtch();
  291.                 clrbpt(bpt, MAXBPTS);
  292.             }
  293.         } else
  294.             ptrace(SSTEP, 0, 0, 0);
  295.         dot = *(regs[PC].value);
  296.  
  297.         switch (lasttrap) {
  298.         case 2:
  299.         case 3:
  300.             prbuserr();
  301.             break;
  302.         case 4:        /* illegal instruction */
  303.             if (bp = findbpt(dot)) {
  304.                 hitbpt(bp);
  305.                 break;
  306.             }
  307.             /* fall through */
  308.         default:
  309.             prtf("trap: %s\n", tnm[lasttrap]);
  310.             break;
  311.         case 9:        /* trace trap */
  312.             break;
  313.         case 10:    /* exit */
  314. /*            prt("process exited\n");    */
  315.             prt(M12);
  316.             seeerr();
  317.             exit(0);
  318.         }
  319.  
  320.         if (c == 'S' || c == 'C')
  321.             prregs();
  322.         prbpt(dot);
  323.         return(0);
  324.     case 'b':        /* set break point */
  325.         if (bp = freebpt(dot)) {
  326.             bp->flag |= BP_VALID;
  327.             bp->addr = dot;
  328.         } else
  329. /*            prt("too many breakpoints\n");    */
  330.             prt(M15);
  331.         break;
  332.     case 'd':        /* clear break point */
  333.         if (bp = findbpt(dot))
  334.             bp->flag = 0;
  335.         else
  336. /*            prt("no breakpoint found\n");    */
  337.             prt(M16);
  338.         break;
  339.     default:
  340. /*        prt("unknown command\n");    */
  341.         prt(M13);
  342.         break;
  343.     }
  344.     return(0);
  345. }
  346.  
  347. getargs()
  348. {
  349.     char c, *cp;
  350.     int n;
  351.     static int gotargs = 0;
  352.  
  353.     c = nb();
  354.     if (c == '\n')
  355.         return;
  356.  
  357.     if (gotargs)
  358.         return;
  359.     gotargs++;
  360.  
  361.     n = 1;
  362.     cp = &bpage->p_cmdlin[1];
  363.     *cp++ = c;
  364.     while ((c = getchr()) != '\n') {
  365.         *cp++ = c;
  366.         n++;
  367.         if (n >= 0x7e)
  368.             break;
  369.     }
  370.     bpage->p_cmdlin[0] = n;
  371.     *cp = 0;
  372.     pushc('\n');
  373. }
  374.  
  375. cleanup(fp)
  376. struct file *fp;
  377. {
  378.  
  379.     ptrace(KILL_PID, fp->pid, 0, 0);
  380.     return;
  381. }
  382.  
  383. prbpt(pc)
  384. long pc;
  385. {
  386.     dot = pc;
  387.     dotoff = 0;
  388.     prtad(dot+dotoff);
  389.     putchr(':');
  390.     puti();
  391.     putchr('\n');
  392.     return;
  393. }
  394.  
  395. setbpt(bp, n)
  396. struct bpt *bp;
  397. int n;
  398. {
  399.  
  400.     while (n--) {
  401.         if (bp->flag & BP_VALID) {
  402.             bp->flag |= BP_ACTIVE;
  403.             bp->instr = getn(bp->addr, 2);
  404.             putn((long)BPT, bp->addr, 2);
  405.         }
  406.         bp++;
  407.     }
  408.     return;
  409. }
  410.  
  411. clrbpt(bp, n)
  412. struct bpt *bp;
  413. int n;
  414. {
  415.     while (n--) {
  416.         if (bp->flag & BP_ACTIVE) {
  417.             bp->flag &= ~BP_ACTIVE;
  418.             putn((long)bp->instr, bp->addr, 2);
  419.         }
  420.         bp++;
  421.     }
  422.     return;
  423. }
  424.  
  425. struct bpt *
  426. freebpt(dot)
  427. long dot;
  428. {
  429.     extern struct bpt bpt[];
  430.     struct bpt *bp, *lp;
  431.     int n;
  432.  
  433.     bp = bpt;
  434.     lp = 0;
  435.     n = MAXBPTS;
  436.     while (n--)
  437.         if ((bp->flag & BP_VALID) == 0 && lp == 0)
  438.             lp = bp;
  439.         else if (bp->addr == dot)
  440.             return(bp);
  441.         else
  442.             bp++;
  443.     return(lp);
  444. }
  445.  
  446. struct bpt *
  447. findbpt(dot)
  448. long dot;
  449. {
  450.     extern struct bpt bpt[];
  451.     struct bpt *bp;
  452.     int n;
  453.  
  454.     bp = bpt;
  455.     n = MAXBPTS;
  456.     while (n--)
  457.         if ((bp->flag & BP_VALID) && bp->addr == dot)
  458.             return(bp);
  459.         else
  460.             bp++;
  461.     return NULL;
  462. }
  463.  
  464. hitbpt(bp)
  465. struct bpt *bp;
  466. {
  467. /*    prtf("break at %I\n", dot);    */
  468.     prtf(M14, dot);
  469. }
  470.